﻿#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include"String.h"
using namespace std;


//int main()
//{	
//	auto add = [](int x, int y){ return x + y; };
//	cout << add(1, 2)<<endl;
//	auto fun1 = [] {cout << "hello world!"; };
//	fun1();
//	cout << endl;
//
//	int a = 0, b = 1;
//	auto swap1 = [](int& x, int& y)
//	{
//		int tmp = x;
//		x = y;
//		y = tmp;
//	};
//	swap1(a, b);
//	cout << a << ":" << b << endl;
//	return 0;
//}

//int x = 0;
//// 捕捉列表必须为空，因为全局变量不⽤捕捉就可以⽤，没有可被捕捉的变量
//auto func1 = []()
//{
//	x++;
//};
//int main()
//{
//	int a = 0, b = 0;
//	auto fun = [=,&a] {
//		a++;
//	};
//	func1();
//	cout << x;
//}

//int x = 0;
//
//int main()
//{
//	int a = 0, b = 1, c = 2, d = 3;
//	auto func1 = [a, &b]
//	{
//		// 值捕捉的变量不能修改，引⽤捕捉的变量可以修改
//		//a++;
//		b++;
//		int ret = a + b;
//		return ret;
//	};
//	cout << func1() << endl;
//
//	// 隐式值捕捉
//	// ⽤了哪些变量就捕捉哪些变量
//	auto func2 = [=]
//	{
//		int ret = a + b + c;
//		return ret;
//	};
//	cout << func2() << endl;
//
//	// 隐式引⽤捕捉
//	// ⽤了哪些变量就捕捉哪些变量
//	auto func3 = [&]
//	{
//		a++;
//		c++;
//		d++;
//	};
//	func3();
//	cout << a << " " << b << " " << c << " " << d << endl;
//
//	// 混合捕捉1
//	auto func4 = [&, a, b]
//	{
//		//a++;
//		//b++;
//		c++;
//		d++;
//		return a + b + c + d;
//	};
//	func4();
//	cout << a << " " << b << " " << c << " " << d << endl;
//
//	// 混合捕捉2
//	auto func5 = [=, &a, &b]
//	{
//		a++;
//		b++;
//		/*c++;
//		d++;*/
//		return a + b + c + d;
//	};
//	func5();
//	cout << a << " " << b << " " << c << " " << d << endl;
//
//	// 局部的静态和全局变量不能捕捉，也不需要捕捉
//	static int m = 0;
//	auto func6 = []
//	{
//		int ret =  x+m;
//		return ret;
//	};
//	cout << func6() << endl;
//
//	// 传值捕捉本质是⼀种拷⻉,并且被const修饰了
//	// mutable相当于去掉const属性，可以修改了,使⽤该修饰符后，参数列表不可省略(即使参数为空)
//	// 但是修改了不会影响外⾯被捕捉的值，因为是⼀种拷⻉
//	auto func7 = [=]()mutable
//	{
//		a++;
//		b++;
//		c++;
//		d++;
//		return a + b + c + d;
//	};
//	cout << func7() << endl;
//	cout << a << " " << b << " " << c << " " << d << endl;
//	return 0;
//}


//class Rate
//{
//public:
//	Rate(double rate)
//		: _rate(rate)
//	{}
//	double operator()(double money, int year)
//	{
//		return money * _rate * year;
//	}
//private:
//	double _rate;
//};
//
//int main()
//{
//	double rate = 0.49;
//
//	// lambda
//	auto r2 = [rate](double money, int year) {
//		return money * rate * year;
//	};
//	// 函数对象
//	Rate r1(rate);
//
//	r1(10000, 2);
//	r2(10000, 2);
//	return 0;
//}

//class Person
//{
//public:
//	Person(const char* name = "张三", int age = 18)
//		:_name(name)
//		, _age(age)
//	{}
//
//	Person(const Person& p)
//		:_name(p._name)
//		, _age(p._age)
//	{}
//
//	Person(Person&& p) = default;
//	//Person(const Person& p) = delete;
//
//private:
//	bao::string _name;
//	int _age;
//};
//
//int main()
//{
//	Person s1;
//	//Person s2 = s1;
//	Person s3 = std::move(s1);
//	return 0;
//}


#include<functional>
//int f(int a, int b)
//{
//	return a + b;
//}
//
//struct Functor
//{
//public:
//	int operator() (int a, int b)
//	{
//		return a + b;
//	}
//};
//
//class Plus
//{
//public:
//	Plus(int n = 10)
//		:_n(n)
//	{}
//	static int plusi(int a, int b)
//	{
//		return a + b;
//	}
//	double plusd(double a, double b)
//	{
//		return (a + b) * _n;
//	}
//private:
//	int _n;
//};
//
//int main()
//{
//	// 包装各种可调⽤对象
//	function<int(int, int)> f1 = f;
//	function<int(int, int)> f2 = Functor();
//	function<int(int, int)> f3 = [](int a, int b) {return a + b; };
//	cout << f1(1, 1) << endl;
//	cout << f2(1, 1) << endl;
//	cout << f3(1, 1) << endl;
//
//	// 包装静态成员函数
//	// 成员函数要指定类域并且前⾯加&才能获取地址
//	function<int(int, int)> f4 = &Plus::plusi;
//	cout << f4(1, 1) << endl;
//
//	// 包装普通成员函数
//	// 普通成员函数还有⼀个隐含的this指针参数，所以绑定时传对象或者对象的指针过去都可以
//	function<double(Plus*, double, double)> f5 = &Plus::plusd;
//	Plus pd;
//	cout << f5(&pd, 1.1, 1.1) << endl;
//
//	function<double(Plus, double, double)> f6 = &Plus::plusd;
//	cout << f6(pd, 1.1, 1.1) << endl;
//	cout << f6(Plus(), 1.1, 1.1) << endl;
//
//	function<double(Plus&&, double, double)> f7 = &Plus::plusd;
//	cout << f7(move(pd), 1.1, 1.1) << endl;
//	cout << f7(Plus(), 1.1, 1.1) << endl;
//	return 0;
//}
//#include<stack>
//#include<map>
//
//
//// 使⽤map映射string和function的⽅式实现
//// 这种⽅式的最⼤优势之⼀是⽅便扩展，假设还有其他运算，我们增加map中的映射即可
//class Solution {
//public:
//	int evalRPN(vector<string>& tokens) {
//		stack<int> st;
//		// function作为map的映射可调⽤对象的类型
//		map<string, function<int(int, int)>> opFuncMap = {
//		{"+", [](int x, int y) {return x + y; }},
//		{"-", [](int x, int y) {return x - y; }},
//		{"*", [](int x, int y) {return x * y; }},
//		{"/", [](int x, int y) {return x / y; }}
//		};
//		for (auto& str : tokens)
//		{
//			if (opFuncMap.count(str)) // 操作符
//			{
//				int right = st.top();
//				st.pop();
//				int left = st.top();
//				st.pop();
//				int ret = opFuncMap[str](left, right);
//				st.push(ret);
//			}
//			else
//			{
//				st.push(stoi(str));
//			}
//		}
//		return st.top();
//	}
//};

//simple(1)
//template <class Fn, class... Args>
///* unspecified */ bind(Fn&& fn, Args&&... args);
//with return type(2)
//template <class Ret, class Fn, class... Args>
///* unspecified */ bind(Fn && fn, Args&&... args);

//#include<functional>
//using placeholders::_1;
//using placeholders::_2;
//using placeholders::_3;
//int Sub(int a, int b)
//{
//	return (a - b) * 10;
//}
//int SubX(int a, int b, int c)
//{
//	return (a - b - c) * 10;
//}
//class Plus
//{
//public:
//	static int plusi(int a, int b)
//	{
//		return a + b;
//	}
//	double plusd(double a, double b)
//	{
//		return a + b;
//	}
//};
//
//int main()
//{
//	auto sub1 = bind(Sub, _1, _2);
//	cout << sub1(10, 5) << endl;
//	// bind 本质返回的⼀个仿函数对象
//	// 调整参数顺序（不常⽤）
//	// _1代表第⼀个实参
//	// _2代表第⼆个实参
//	// ...
//	auto sub2 = bind(Sub, _2, _1);
//	cout << sub2(10, 5) << endl;
//
//	// 调整参数个数 （常⽤）
//	auto sub3 = bind(Sub, 100, _1);
//	cout << sub3(5) << endl;
//	auto sub4 = bind(Sub, _1, 100);
//	cout << sub4(5) << endl;
//	// 分别绑死第1、2、3个参数
//	auto sub5 = bind(SubX, 100, _1, _2);
//	cout << sub5(5, 1) << endl;
//	auto sub6 = bind(SubX, _1, 100, _2);
//	cout << sub6(5, 1) << endl;
//	auto sub7 = bind(SubX, _1, _2, 100);
//	cout << sub7(5, 1) << endl;
//
//	// 成员函数对象进⾏绑死，就不需要每次都传递了
//	function<double(Plus&&, double, double)> f6 = &Plus::plusd;
//	Plus pd;
//	cout << f6(move(pd), 1.1, 1.1) << endl;
//	cout << f6(Plus(), 1.1, 1.1) << endl;
//	// bind⼀般⽤于，绑死⼀些固定参数
//	function<double(double, double)> f7 = bind(&Plus::plusd, Plus(), _1, _2);
//	cout << f7(1.1, 1.1) << endl;
//
//	// 计算复利的lambda
//	auto func1 = [](double rate, double money, int year)->double {
//		double ret = money;
//		for (int i = 0; i < year; i++)
//		{
//			ret += ret * rate;
//		}
//		return ret - money;
//	};
//	// 绑死⼀些参数，实现出⽀持不同年华利率，不同⾦额和不同年份计算出复利的结算利息
//	function<double(double)> func3_1_5 = bind(func1, 0.015, _1, 3);
//	function<double(double)> func5_1_5 = bind(func1, 0.015, _1, 5);
//	function<double(double)> func10_2_5 = bind(func1, 0.025, _1, 10);
//	function<double(double)> func20_3_5 = bind(func1, 0.035, _1, 30);
//	cout << func3_1_5(1000000) << endl;
//	cout << func5_1_5(1000000) << endl;
//	cout << func10_2_5(1000000) << endl;
//	cout << func20_3_5(1000000) << endl;
//	return 0;
//}

